package 正则表达式;



//分割字符串
//使用正则表达式分割字符串可以实现更加灵活的功能。String.split()方法传入的正是正则表达式。我们来看下面的代码：
//
//"a b c".split("\\s"); // { "a", "b", "c" }
//"a b  c".split("\\s"); // { "a", "b", "", "c" }
//"a, b ;; c".split("[\\,\\;\\s]+"); // { "a", "b", "c" }
//如果我们想让用户输入一组标签，然后把标签提取出来，因为用户的输入往往是不规范的，这时，使用合适的正则表达式，就可以消除多个空格、混合,和;这些不规范的输入，
//直接提取出规范的字符串。
//
//《搜索字符串》
//使用正则表达式还可以搜索字符串，我们来看例子：
/*import java.util.Arrays;
import java.util.regex.*;

public class 搜索和替换 {
    public static void main(String[] args) {
        String s = "the quick brown fox jumps over the lazy dog.";
        Pattern p = Pattern.compile("\\wo\\w+");
        Matcher m = p.matcher(s);

        while (m.find()) {

            String sub = s.substring(m.start(), m.end());
            System.out.println(sub);
        }
        
        
        System.out.println(Arrays.toString("a b c".split("\\s")));
        System.out.println(Arrays.toString("a b  c".split("\\s")));
        System.out.println(Arrays.toString("a, b ;; c".split("[\\,\\;\\s]+")));
    }
}*/

//我们获取到Matcher对象后，不需要调用matches()方法（因为匹配整个串肯定返回false），而是反复调用find()方法(每次向后查找，直至未找到，即find()返回false)，
//在整个串中搜索能匹配上\\wo\\w规则的子串，并打印出来。这种方式比String.indexOf()要灵活得多，因为我们搜索的规则是3个字符：中间必须是o，前后两个必须是字
//符[A-Za-z0-9_]。
//
//《替换字符串》
//使用正则表达式替换字符串可以直接调用String.replaceAll()，它的第一个参数是正则表达式，第二个参数是待替换的字符串。我们还是来看例子：

// regex
/*public class 搜索和替换 {
    public static void main(String[] args) {
        String s = "The     quick\t\t brown   fox  jumps   over the  lazy dog.";
        String r = s.replaceAll("\\s+", " ");
        System.out.println(r); // "The quick brown fox jumps over the lazy dog."
    }
}*/

//上面的代码把不规范的连续空格分隔的句子变成了规范的句子。可见，灵活使用正则表达式可以大大降低代码量

//《反向引用》
//如果我们要把搜索到的指定字符串按规则替换，比如前后各加一个<b>xxxx</b>，这个时候，使用replaceAll()的时候，我们传入的第二个参数可以使用$1、$2来反向
//引用匹配到的子串。例如：

// regex
/*public class 搜索和替换 {
    public static void main(String[] args) {
        String s = "the quick brown fox jumps over the lazy dog.";
        String r = s.replaceAll("\\s([a-z]{4})\\s", " <b>$1</b> ");
//                               $0    $1      $2
        System.out.println(r);
    }
}*/

//上述代码的运行结果是： the quick brown fox jumps <b>over</b> the <b>lazy</b> dog.
//它实际上把任何4字符单词的前后用<b>xxxx</b>括起来。实现替换的关键就在于" <b>$1</b> "，它用匹配的分组子串([a-z]{4})替换了$1。

/*import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class 搜索和替换 {
    public static void main(String[] args) {
    	Pattern p = Pattern.compile("cat");
    	Matcher m = p.matcher("one cat two cats in the yard");
    	StringBuilder sb = new StringBuilder();
    	while (m.find()) {
    	    m.appendReplacement(sb, "dog");//找到匹配子串，替换之，在上次追加的字符串后，连同本次匹配前面的字符串一并追加至sb。
    	    System.out.println(sb.toString());
    	}
    	m.appendTail(sb);//将最后匹配之后的字符串追加至sb
    	System.out.println(sb.toString());

    }
}*/

//《练习》
//模板引擎是指，定义一个字符串作为模板：
//
//Hello, ${name}! You are learning ${lang}!
//其中，以${key}表示的是变量，也就是将要被替换的内容
//
//当传入一个Map<String, String>给模板后，需要把对应的key替换为Map的value。
//
//例如，传入Map为：
//
//{
//    "name": "Bob",
//    "lang": "Java"
//}
//然后，${name}被替换为Map对应的值"Bob”，${lang}被替换为Map对应的值"Java"，最终输出的结果为：
//
//Hello, Bob! You are learning Java!
//请编写一个简单的模板引擎，利用正则表达式实现这个功能。
//
//提示：参考Matcher.appendReplacement()方法。
//方式一：
/*import java.util.Map;
import java.util.HashMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class 搜索和替换 {
    public static void main(String[] args) {
    	String st="Hello, ${name}! You are learning ${lang}! ${name}";
    	Map<String,String> map=new HashMap<>();
    	map.put("name","Bob");
    	map.put("lang", "Jave");
    	for (String key:map.keySet()) {
    		String rg="\\$\\{"+key+"\\}";
    		Pattern pt=Pattern.compile(rg);
    		Matcher mc=pt.matcher(st);
    		StringBuilder sb=new StringBuilder();
    		while(mc.find()) {
    			mc.appendReplacement(sb, map.get(key));
    		}
    		mc.appendTail(sb);
    		st=sb.toString();
    	}
    	System.out.println(st);//Hello, Bob! You are learning Jave! Bob
    }
}*/


import java.util.Map;
import java.util.HashMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class 搜索和替换 {
    public static void main(String[] args) {
    	String st="Hello, ${name}! You are learning ${lang}! ${name}";
    	Map<String,String> map=Map.of("name","Bob","lang", "Jave");
//    	Map<String,String> map=new HashMap<>();
//    	map.put("name","Bob");
//    	map.put("lang", "Jave");
    	for (Map.Entry<String,String> entry :map.entrySet()) {
    		String rg="\\$\\{"+entry.getKey()+"\\}";
//    		st.replaceAll(rg,entry.getValue());//不会改变st的值,整个式子返回一个值
    		String mst=st.replaceAll(rg,entry.getValue());
    		st=mst;
    	}
    	System.out.println(st);//Hello, Bob! You are learning Jave! Bob
    	String str = "11.3.22.11";   
//    	str=str.replaceAll("(^|\\.)(\\d)(\\.|$)","$000$2$3");   
    	System.out.println(str);   
    	str=str.replaceAll("(^|\\.)(\\d{1})(\\.|$)","$10$2$3");   
    	System.out.println(str);   
    	str=str.replaceAll("(^|\\.)(\\d{2})(\\.|$)","$10$2$3");   
    	System.out.println(str);   
    	str=str.replaceAll("(^|\\.)(\\d{1})(\\.|$)","$100$2$3");   
    	System.out.println(str);  

    	
    	// 同时替换多个文字
        String str1 = "广东省，福建省，北京市，海淀区，河北省，上海市";
        str1 = str1.replaceAll("省|市", "");
        System.out.println("替换多个中文：" + str1);
 
        // 同时替换多个字符
        String str2 = "0*00*00//33?23?23/";
        str2= str2.replaceAll("\\*|\\/|\\?","");
        System.out.println("替换多个字符：" + str2);
    }
}

//《小结》
//使用正则表达式可以：
//
//分割字符串：String.split()
//搜索子串：Matcher.find()
//替换字符串：String.replaceAll()




